Method and apparatus for concurrently executing multiplication and iterative operations

ABSTRACT

A multiplier capable of performing complex iterative calculations such as division and square root concurrently with simple independent multiplication operations is disclosed. The division and square root operations are performed using iterative multiplication operations such as the Newton Raphson iteration and series expansion. These iterative calculations may require a number of passes through the multiplier. Since the multiplier may be pipelined, it may experience a number of idle cycles during the iterative calculations. The multiplier is configured to utilize these idle cycles to perform independent simple multiplication operations. The multiplier may be configured to assert a control signal that is indicative of future idle cycles in the first stages of the multiplier pipeline. The control signal may be used by control logic to dispatch independent simple multiplication operations to the multiplier for execution during the idle clock cycles. The multiplier may also be configured to concurrently execute two independent iterative operations.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates generally to the field of microprocessors and, more particularly, to multiplication arithmetic units within microprocessors.

2. Description of the Related Art

Microprocessors are typically designed with a number of “execution units” that are each optimized to perform a particular set of functions or instructions. For example, one or more execution units within a microprocessor may be optimized to perform memory accesses, i.e., load and store operations. Other execution units may be optimized to perform general arithmetic and logic functions, e.g., shifts and compares. Many microprocessors also have specialized execution units configured to perform more complex arithmetic operations such as multiplication and reciprocal operations. These specialized execution units typically comprise hardware that is optimized to perform one or more particular arithmetic functions. In the case of multiplication, the optimized hardware is typically referred to as a “multiplier.”

In older microprocessors, multipliers were implemented using designs that conserved die space at the expense of arithmetic performance. Until recently, this was not a major problem because most applications, i.e., non-scientific applications such as word processors, did not frequently generate multiplication instructions. However, recent advances in computer technology and software are placing greater emphasis upon multiplier performance. For example, three dimensional computer graphics, rendering, and multimedia applications all rely heavily upon a microprocessor's arithmetic capabilities, particularly multiplication and multiplication-related operations. As a result, in recent years microprocessor designers have favored performance-oriented designs that use more die space. Unfortunately, the increased die space needed for these high performance multipliers reduces the space available for other execution units within the microprocessor. Thus, a mechanism for increasing multiplier performance while conserving die space in needed.

The die space used by multipliers is of particular importance to microprocessor designers because many microprocessors, e.g., those configured to execute MMX™ (multimedia extension) or 3D graphics instructions, may use more than one multiplier. MMX and 3D graphics instructions are often implemented as “vectored” instructions. Vectored instructions have operands that are partitioned into separate sections, each of which is independently operated upon. For example, a vectored multiply instruction may operate upon a pair of 32-bit operands, each of which is partitioned into two 16-bit sections or four 8-bit sections. Upon execution of a vectored multiply instruction, corresponding sections of each operand are independently multiplied. FIG. 1 illustrates the differences between a scalar (i.e., non-vectored) multiplication and a vector multiplication. To quickly execute vectored multiply instructions, many microprocessors use a number of multipliers in parallel.

Another factor that may affect the die space used by multipliers within a microprocessor is the microprocessor's ability to operate upon multiple data types. Most microprocessors must support multiple data types. For example, x86 compatible microprocessors must execute instructions that are defined to operate upon an integer data type and instructions that are defined to operate upon floating point data types. Floating point data can represent numbers within a much larger range than integer data. For example, a 32-bit signed integer can represent the integers between −2³¹ and 2³¹−1 (using two's complement format). In contrast, a 32-bit (“single precision”) floating point number as defined by the Institute of Electrical and Electronic Engineers (IEEE) Standard 754 has a range (in normalized format) from 2⁻¹²⁶ to 2¹²⁷×(2−2⁻²³) in both positive and negative numbers. While both integer and floating point data types are capable of representing positive and negative values, integers are considered to be “signed” for multiplication purposes, while floating point numbers are considered to be “unsigned.” Integers are considered to be signed because they are stored in two's complement representation.

Turning now to FIG. 2A, an exemplary format for an 8-bit integer 100 is shown. As illustrated in the figure, negative integers are represented using the two's complement format 104. To negate an integer, all bits are inverted to obtain the one's complement format 102. A constant of one is then added to the least significant bit (LSB).

Turning now to FIG. 2B, an exemplary format for a 32-bit (single precision) floating point number is shown. A floating point number is represented by a significand, an exponent and a sign bit. The base for the floating point number is raised to the power of the exponent and multiplied by the significand to arrive at the number represented. In microprocessors, base 2 is typically used. The significand comprises a number of bits used to represent the most significant digits of the number. Typically, the significand comprises one bit to the left of the radix point and the remaining bits to the right of the radix point. In order to save space, the bit to the left of the radix point, known as the integer bit, is not explicitly stored. Instead, it is implied in the format of the number. Additional information regarding floating point numbers and operations performed thereon may be obtained in IEEE Standard 754. Unlike the integer representation, two's complement format is not typically used in the floating point representation. Instead, sign and magnitude form are used. Thus, only the sign bit is changed when converting from a positive value 106 to a negative value 108. For this reason, some microprocessors use two multipliers, i.e., one for signed values (two's complement format) and another for unsigned values (sign and magnitude format). This places further constraints upon the die space used by each multiplier.

Another crucial factor that may affect the amount of die space allocated to a multiplier is the number of other functions that the multiplier is capable of executing. If a particular multiplier is capable of executing other types of instructions, e.g., division and square root functions, it may be allocated more die space because it alleviates the need for additional hardware, e.g., a dedicated division circuit.

For the reasons set forth above, a method for increasing multiplier performance and utility while conserving die space is needed.

SUMMARY

The problems outlined above are in large part solved by a multiplier configured in accordance with the present invention. In one embodiment, the multiplier may be configured to execute simple independent multiplication operations and complex iterative operations concurrently. The ability to perform iterative calculations advantageously allows the multiplier to perform calculations such as division and square root, thereby reducing die space constraints. The ability to concurrently execute these iterative instructions with multiplications instructions may improve the throughput of the multiplier while reducing the need for using more than one multiplier.

In one embodiment, the multiplier may comprise a plurality of pipeline stages, some of which are idle for particular clock cycles during the execution of a complex iterative operation. The multiplier may be configured to generate a control signal indicative of the occurrence of these idle clock cycles. The control signal may then by used to select and route independent no simple multiplication instructions to the multiplier for execution during the idle clock cycles. In another embodiment, the multiplier may also be configured concurrently execute two independent complex iterative calculations. The multiplier's availability during a particular clock cycle to perform an second instruction concurrently may be a function of the type of iterative operation being performed and the number of clock cycles between the particular clock cycle and the first clock cycle during which the multiplier began executing the first complex iterative operation. In some embodiments, the multiplier may be configured to store the intermediate products produced by the iterative calculations. Advantageously, some embodiments of the multiplier may be configured to compress these intermediate products before storing them, further conserving die space.

A method for executing independent multiplication and iterative instructions concurrently is also contemplated. In one embodiment the method comprises beginning execution of an iterative instruction in a pipelined multiplier, wherein the iterative instruction requires a first number of clock cycles to complete. A control signal is asserted during the first number of clock cycles if the multiplier will be available to begin execution of an independent multiplication instruction in a predetermined number of clock cycles. Upon detecting an asserted control signal, an independent multiplication instruction is dispatched to the multiplier. Execution of the independent multiplication instruction may begin and complete before the iterative instruction has completed executing.

In another embodiment, the multiplier may also be configured to perform signed and unsigned scalar and vector multiplication using the same hardware. The multiplier may also be configured to calculate vector dot products. The multiplier may receive either signed or unsigned operands in either scalar or packed vector format and accordingly output a signed or unsigned result that is either a scalar or a vector quantity. Advantageously, this embodiment may reduce the total number of multipliers needed within a microprocessor because it may be shared by execution units and perform both scalar and vector multiplication. This space savings may in turn allow designers to optimize the multiplier for speed without fear of using too much die space.

In yet another embodiment, the multiplier may be configured to output the results in segments or portions, which may be rounded. This may advantageously reduce the amount of interface logic and the number of bus lines that may be needed to support the multiplier.

In still another embodiment, the speed of the multiplier may be increased by configuring the multiplier to perform fast rounding and normalization. This may be accomplished configuring the multiplier to calculate two version of an operand, e.g., an overflow version and a non-overflow version, in parallel.

BRIEF DESCRIPTION OF THE DRAWINGS

Other objects and advantages of the invention will become apparent upon reading the following detailed description and upon reference to the accompanying drawings in which:

FIG. 1 is a diagram illustrating an exemplary scalar multiplication and an exemplary vector multiplication.

FIG. 2A is a diagram of an exemplary integer data format using two's complement representation.

FIG. 2B is a diagram of an exemplary floating point data format.

FIG. 3 is a block diagram of one embodiment of an exemplary microprocessor.

FIG. 3A is a block diagram of one embodiment of the floating point unit from the microprocessor of FIG. 3.

FIG. 4 is a block diagram illustrating details of one embodiment of the multiplier from FIG. 3.

FIG. 5A illustrates one embodiment of the shift-and-add algorithm for binary multiplication.

FIG. 5B illustrates one embodiment of Booth's algorithm for binary multiplication.

FIG. 6 is a chart depicting the timing in one embodiment of the multiplier from FIG. 3.

FIG. 7 is a block diagram of one embodiment of the multiplier from FIG. 3 that is configured to concurrently execute instructions.

FIG. 8 is a chart depicting one embodiment of the timing of the multiplier from FIG. 7.

FIG. 9 is a diagram illustrating one embodiment of which inputs are selected during iteration clock cycles.

FIG. 10 is a block diagram of one embodiment of a computer system configured to utilize the microprocessor of FIG. 3.

While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the present invention as defined by the appended claims.

DETAILED DESCRIPTION OF AN EMBODIMENT

Turning now to FIG. 3, a block diagram of one embodiment of a microprocessor 10 is shown. Microprocessor 10 includes a prefetch/predecode unit 12, a branch prediction unit 14, an instruction cache 16, an instruction alignment unit 18, a plurality of decode units 20A-20C, a plurality of reservation stations 22A-22C, a plurality of functional units 24A-24C, a load/store unit 26, a data cache 28, a register file 30, a reorder buffer 32, an MROM unit 34, and a floating point unit (FPU) 36, which in turn comprises multiplier 50. Before examining one embodiment of multiplier 50 in detail, the operation of microprocessor 10 will be briefly discussed. Note that elements referred to herein with a particular reference number followed by a letter may be collectively referred to by the reference number alone. For example, decode units 20A-20C may be collectively referred to as decode units 20.

Prefetch/predecode unit 12 is coupled to receive instructions from a main memory subsystem (not shown), and is further coupled to instruction cache 16 and branch prediction unit 14. Similarly, branch prediction unit 14 is coupled to instruction cache 16. Still further, branch prediction unit 14 is coupled to decode units 20 and functional units 24. Instruction cache 16 is further coupled to MROM unit 34 and instruction alignment unit 18. Instruction alignment unit 18, which comprises an early decode unit (EDU) 44, is in turn coupled to decode units 20. Each decode unit 20A-20C is coupled to load/store unit 26 and to respective reservation stations 22A-22C. Reservation stations 22A-22C are further coupled to respective functional units 24A-24C. Additionally, decode units 20 and reservation stations 22 are coupled to register file 30 and reorder buffer 32. Functional units 24 are coupled to load/store unit 26, register file 30, and reorder buffer 32 as well. Data cache 28 is coupled to load/store unit 26 and to the main memory subsystem. MROM unit 34, which also comprises an early decode unit (EDU) 42 is coupled to decode units 20 and FPU 36. Finally, FPU 36 is coupled to load/store unit 26 and reorder buffer 32.

Instruction cache 16 is a high speed cache memory provided to store instructions. Instructions are fetched from instruction cache 16 and dispatched to decode units 20. In one embodiment, instruction cache 16 is configured to store up to 32 kilobytes of instructions in a 4-way set associative structure having 32-byte lines (a byte comprises 8 binary bits). Instruction cache 16 may additionally employ a way prediction scheme in order to speed access times to the instruction cache. Instead of accessing tags identifying each line of instructions and comparing the tags to the fetch address to select a way, instruction cache 16 may predict the way that is accessed. In this manner, the way is selected prior to accessing the instruction storage. The access time of instruction cache 16 may be similar to a direct-mapped cache. A tag comparison is performed and, if the way prediction is incorrect, the correct instructions are fetched and the incorrect instructions are discarded. It is noted that instruction cache 16 may be implemented in a fully-associative, set-associative, or direct-mapped configuration.

Instructions are fetched from main memory and stored into instruction cache 16 by prefetch/predecode unit 12. Instructions may be prefetched prior to the request thereof in accordance with a prefetch scheme. A variety of prefetch schemes may be employed by prefetch/predecode unit 12. As prefetch/predecode unit 12 transfers instructions from main memory to instruction cache 16, prefetch/predecode unit 12 generates three predecode bits for each byte of the instructions: a start bit, an end bit, and a functional bit. The predecode bits form tags indicative of the boundaries of each instruction. The predecode tags may also convey additional information such as whether a given instruction may be decoded directly by decode units 20 or whether the instruction is executed by invoking a microcode procedure controlled by MROM unit 34, as will be described in greater detail below. Still further, prefetch/predecode unit 12 may be configured to detect branch instructions and to store branch prediction information corresponding to the branch instructions into branch prediction unit 14.

One encoding of the predecode tags for an embodiment of microprocessor 10 employing a variable byte length instruction set will next be described. A variable byte length instruction set is an instruction set in which different instructions may occupy differing numbers of bytes. An exemplary variable byte length instruction set employed by one embodiment of microprocessor 10 is the x86 instruction set.

In the exemplary encoding, if a given byte is the first byte of an instruction, the start bit for that byte is set. If the byte is the last byte of an instruction, the end bit for that byte is set. Instructions which may be directly decoded by decode units 20 are referred to as “fast path” instructions. The remaining x86 instructions are referred to as MROM instructions, according to one embodiment. For fast path instructions, the functional bit is set for each prefix byte included in the instruction, and cleared for other bytes. Alternatively, for MROM instructions, the functional bit is cleared for each prefix byte and set for other bytes. The type of instruction may be determined by examining the functional bit corresponding to the end byte. If that functional bit is clear, the instruction is a fast path instruction. Conversely, if that functional bit is set, the instruction is an MROM instruction. The opcode of an instruction may thereby be located within an instruction which may be directly decoded by decode units 20 as the byte associated with the first clear functional bit in the instruction. For example, a fast path instruction including two prefix bytes, a Mod R/M byte, and an immediate byte would have start, end, and functional bits as follows:

Start bits 10000 End bits 00001 Functional bits 11000

According to one particular embodiment, early identifying that an instruction includes a scale-index-base (SIB) byte is advantageous for MROM unit 34. For such an embodiment, if an instruction includes at least two bytes after the opcode byte, the functional bit for the Mod R/M byte indicates the presence of an SIB byte. If the fuinctional bit for the Mod R/M byte is set, then an SIB byte is present. Alternatively, if the functional bit for the Mod R/M byte is clear, then an SIB byte is not present.

MROM instructions are instructions which are determined to be too complex for decode by decode units 20. MROM instructions are executed by invoking MROM unit 34. More specifically, when an MROM instruction is encountered, MROM unit 34 parses and issues the instruction into a subset of defined fast path instructions to effectuate the desired operation. MROM unit 34 dispatches the subset of fast path instructions to decode units 20.

Microprocessor 10 employs branch prediction in order to speculatively fetch instructions subsequent to conditional branch instructions. Branch prediction unit 14 is included to perform branch prediction operations. In one embodiment, up to two branch target addresses are stored with respect to each 16 byte portion of each cache line in instruction cache 16. Prefetch/predecode unit 12 determines initial branch targets when a particular line is predecoded. Subsequent updates to the branch targets corresponding to a cache line may occur due to the execution of instructions within the cache line. Instruction cache 16 provides an indication of the instruction address being fetched, so that branch prediction unit 14 may determine which branch target addresses to select for forming a branch prediction. Decode units 20 and functional units 24 provide update information to branch prediction unit 14. Because branch prediction unit 14 stores two targets per 16 byte portion of the cache line, some branch instructions within the line may not be stored in branch prediction unit 14. Decode units 20 detect branch instructions which were not predicted by branch prediction unit 14. Functional units 24 execute the branch instructions and determine if the predicted branch direction is incorrect. The branch direction may be “taken”, in which subsequent instructions are fetched from the target address of the branch instruction. Conversely, the branch direction may be “not taken”, in which case subsequent instructions are fetched from memory locations consecutive to the branch instruction. When a mispredicted branch instruction is detected, instructions subsequent to the mispredicted branch are discarded from the various units of microprocessor 10. A variety of suitable branch prediction algorithms may be employed by branch prediction unit 14.

Instructions fetched from instruction cache 16 are conveyed to instruction alignment unit 18 and MROM unit 34. As instructions are fetched from instruction cache 16, the corresponding predecode data is scanned to provide information to instruction alignment unit 18 and MROM unit 34 regarding the instructions being fetched. Instruction alignment unit 18 utilizes the scanning data to align an instruction to each of multiplexers 46A-C. In one embodiment, instruction alignment unit 18 aligns instructions from three sets of eight instruction bytes to decode units 20. Similarly, MROM unit 34 is configured to output up to three aligned instructions to multiplexers 46A-C. Note, both instruction alignment unit 18 and MROM unit 34 may each have an early decode unit (EDC) 42 and 44. These units may perform the first steps of the decoding process, e.g., identifying the operand specifiers for each instruction.

Each multiplexer 46A-C is configured to receive a partially decoded instruction (and corresponding decode and predecode information) from instruction alignment unit 18 and MROM unit 34. Each multiplexer 46A-C is configured to select up to one instruction from either instruction alignment unit 18 or MROM unit 34 during each clock cycle. The selected instructions are routed to decode units 20A-C (integer instructions), and FPU 36 (floating point, MMX, and 3D instructions). In one embodiment of microprocessor 10, up to three floating point instructions per clock cycle may be conveyed to floating point unit 36. As note above, the instructions may come from MROM unit 34 (microcode instructions) or instruction alignment unit 18 (fast path instructions).

Decode units 20 are configured to complete decoding instructions received from multiplexers 46A-C. Register operand information is detected and routed to register file 30 and reorder buffer 32. Additionally, if the instructions require one or more memory operations to be performed, decode units 20 dispatch the memory operations to load/store unit 26. Each instruction is decoded into a set of control values for functional units 24, and these control values are dispatched to reservation stations 22 along with operand address information and displacement or immediate data which may be included with the instruction.

Microprocessor 10 supports out of order execution, and thus employs reorder buffer 32 to keep track of the original program sequence for register read and write operations, to implement register renaming, to allow for speculative instruction execution and branch misprediction recovery, and to facilitate precise exceptions. A temporary storage location within reorder buffer 32 is reserved upon decode of an instruction that involves the update of a register to thereby store speculative register states. If a branch prediction is incorrect, the results of speculatively-executed instructions along the mispredicted path can be invalidated in the buffer before they are written to register file 30. Similarly, if a particular instruction causes an exception, instructions subsequent to the particular instruction may be discarded. In this manner, exceptions are “precise” (i.e. instructions subsequent to the particular instruction causing the exception are not completed prior to the exception). It is noted that a particular instruction is speculatively executed if it is executed prior to instructions which precede the particular instruction in program order. Preceding instructions may be a branch instruction or an exception-causing instruction, in which case the speculative results may be discarded by reorder buffer 32.

The instruction control values and immediate or displacement data provided at the outputs of decode units 20 are routed directly to respective reservation stations 22. In one embodiment, each reservation station 22 is capable of holding instruction information (i.e., instruction control values as well as operand values, operand tags and/or immediate data) for up to three pending instructions awaiting issue to the corresponding functional unit. It is noted that for the embodiment of FIG. 3, each reservation station 22 is associated with a dedicated functional unit 24. Accordingly, three dedicated “issue positions” are formed by reservation stations 22 and functional units 24. In other words, issue position 0 is formed by reservation station 22A and functional unit 24A. Instructions aligned and dispatched to reservation station 22A are executed by functional unit 24A. Similarly, issue position 1 is formed by reservation station 22B and functional unit 24B; and issue position 2 is formed by reservation station 22C and functional unit 24C.

Upon decode of a particular instruction, if a required operand is a register location, register address information is routed to reorder buffer 32 and register file 30 simultaneously. Those of skill in the art will appreciate that the x86 register file includes eight 32 bit real registers (i.e., typically referred to as EAX, EBX, ECX, EDX, EBP, ESI, EDI and ESP). In embodiments of microprocessor 10 which employ the x86 microprocessor architecture, register file 30 comprises storage locations for each of the 32 bit real registers. Additional storage locations may be included within register file 30 for use by MROM unit 34. Reorder buffer 32 contains temporary storage locations for results which change the contents of these registers to thereby allow out of order execution. A temporary storage location of reorder buffer 32 is reserved for each instruction which, upon decode, is determined to modify the contents of one of the real registers. Therefore, at various points during execution of a particular program, reorder buffer 32 may have one or more locations which contain the speculatively executed contents of a given register. If following decode of a given instruction it is determined that reorder buffer 32 has a previous location or locations assigned to a register used as an operand in the given instruction, the reorder buffer 32 forwards to the corresponding reservation station either: 1) the value in the most recently assigned location, or 2) a tag for the most recently assigned location if the value has not yet been produced by the functional unit that will eventually execute the previous instruction. If reorder buffer 32 has a location reserved for a given register, the operand value (or reorder buffer tag) is provided from reorder buffer 32 rather than from register file 30. If there is no location reserved for a required register in reorder buffer 32, the value is taken directly from register file 30. If the operand corresponds to a memory location, the operand value is provided to the reservation station through load/store unit 26.

In one particular embodiment, reorder buffer 32 is configured to store and manipulate concurrently decoded instructions as a unit. This configuration will be referred to herein as “line-oriented”. By manipulating several instructions together, the hardware employed within reorder buffer 32 may be simplified. For example, a line-oriented reorder buffer included in the present embodiment allocates storage sufficient for instruction information pertaining to three instructions (one from each decode unit 20) whenever one or more instructions are dispatched by decode units 20. By contrast, a variable amount of storage is allocated in conventional reorder buffers, dependent upon the number of instructions actually dispatched. A comparatively larger number of logic gates may be required to allocate the variable amount of storage. When each of the concurrently decoded instructions has executed, the instruction results are stored into register file 30 simultaneously. The storage is then free for allocation to another set of concurrently decoded instructions. Additionally, the amount of control logic circuitry employed per instruction is reduced because the control logic is amortized over several concurrently decoded instructions. A reorder buffer tag identifying a particular instruction may be divided into two fields: a line tag and an offset tag. The line tag identifies the set of concurrently decoded instructions including the particular instruction, and the offset tag identifies which instruction within the set corresponds to the particular instruction. It is noted that storing instruction results into register file 30 and freeing the corresponding storage is referred to as “retiring” the instructions. It is further noted that any reorder buffer configuration may be employed in various embodiments of microprocessor 10.

As noted earlier, reservation stations 22 store instructions until the instructions are executed by the corresponding functional unit 24. An instruction is selected for execution if both: (i) the operands of the instruction have been provided; and (ii) the operands have not yet been provided for instructions which are within the same reservation station 22A-22C and which are prior to the instruction in program order. It is noted that when an instruction is executed by one of the functional units 24, the result of that instruction is passed directly to any reservation stations 22 that are waiting for that result at the same time the result is passed to update reorder buffer 32 (this technique is commonly referred to as “result forwarding”). An instruction may be selected for execution and passed to a functional unit 24A-24C during the clock cycle that the associated result is forwarded. Reservation stations 22 route the forwarded result to the functional unit 24 in this case.

In one embodiment, each of the functional units 24 is configured to perform integer arithmetic operations of addition and subtraction, as well as shifts, rotates, logical operations, and branch operations. The operations are performed in response to the control values decoded for a particular instruction by decode units 20. Additionally, functional units 24 may be configured to perform address generation for load and store memory operations performed by load/store unit 26.

Each of the functional units 24 also provides information regarding the execution of conditional branch instructions to the branch prediction unit 14. If a branch prediction was incorrect, branch prediction unit 14 flushes instructions subsequent to the mispredicted branch that have entered the instruction processing pipeline, and causes fetch of the required instructions from instruction cache 16 or main memory. It is noted that in such situations, results of instructions in the original program sequence which occur after the mispredicted branch instruction are discarded, including those which were speculatively executed and temporarily stored in load/store unit 26 and reorder buffer 32.

Results produced by functional units 24 are sent to reorder buffer 32 if a register value is being updated, and to load/store unit 26 if the contents of a memory location are changed. If the result is to be stored in a register, reorder buffer 32 stores the result in the location reserved for the value of the register when the instruction was decoded. A plurality of result buses 38 are included for forwarding of results from functional units 24 and load/store unit 26. Result buses 38 convey the result generated, as well as the reorder buffer tag identifying the instruction being executed.

Load/store unit 26 provides an interface between functional units 24 and data cache 28. In one embodiment, load/store unit 26 is configured with a load/store buffer having eight storage locations for data and address information for pending loads or stores. Decode units 20 arbitrate for access to the load/store unit 26. When the buffer is full, a decode unit must wait until load/store unit 26 has room for the pending load or store request information. Load/store unit 26 also performs dependency checking for load memory operations against pending store memory operations to ensure that data coherency is maintained. A memory operation is a transfer of data between microprocessor 10 and the main memory subsystem. Memory operations may be the result of an instruction which utilizes an operand stored in memory, or may be the result of a load/store instruction which causes the data transfer but no other operation. Additionally, load/store unit 26 may include a special register storage for special registers such as the segment registers and other registers related to the address translation mechanism defined by the x86 microprocessor architecture.

In one embodiment, load/store unit 26 is configured to perform load memory operations speculatively. Store memory operations are performed in program order, but may be speculatively stored into the predicted way. If the predicted way is incorrect, the data prior to the store memory operation is subsequently restored to the predicted way and the store memory operation is performed to the correct way. In another embodiment, stores may be executed speculatively as well. Speculatively executed stores are placed into a store buffer, along with a copy of the cache line prior to the update. If the speculatively executed store is later discarded due to branch misprediction or exception, the cache line may be restored to the value stored in the buffer. It is noted that load/store unit 26 may be configured to perform any amount of speculative execution, including no speculative execution.

Data cache 28 is a high speed cache memory provided to temporarily store data being transferred between load/store unit 26 and the main memory subsystem. In one embodiment, data cache 28 has a capacity of storing up to sixteen kilobytes of data in an eight way set associative structure. Similar to instruction cache 16, data cache 28 may employ a way prediction mechanism. It is understood that data cache 28 may be implemented in a variety of specific memory configurations, including a set associative configuration.

In one particular embodiment of microprocessor 10 employing the x86 microprocessor architecture, instruction cache 16 and data cache 28 are linearly addressed. The linear address is formed from the offset specified by the instruction and the base address specified by the segment portion of the x86 address translation mechanism. Linear addresses may optionally be translated to physical addresses for accessing a main memory. The linear to physical translation is specified by the paging portion of the x86 address translation mechanism. It is noted that a linear addressed cache stores linear address tags. A set of physical tags (not shown) may be employed for mapping the linear addresses to physical addresses and for detecting translation aliases. Additionally, the physical tag block may perform linear to physical address translation.

Floating Point Unit

Turning now to FIG. 3A, details of one embodiment of FPU 36 are shown. FPU 36 is a high performance out-of-order execution unit capable of accepting up to three new instructions per clock cycle. The three instructions may be any combination of x86 floating point instructions, MMX instructions, or 3DX instructions. MMX and 3DX instructions are extensions to the standard x86 instruction set. One example of a 3DX instruction set extension is the 3DNow!™ extension from Advanced Micro Devices, Inc. MMX instructions are geared toward multimedia and two-dimensional graphic applications, while 3DX instructions are optimized for performing three-dimensional graphic manipulations such as rendering and texture mapping. Many 3DX instructions are vectored instructions that perform the same operation on a number of independent pairs of operands.

As the figure illustrates, this embodiment of FPU 36 comprises the following components: a rename-1 unit 310, a rename-2 unit 312, a scheduler 314, a retire queue 316, a register file 318, a load/add instruction pipeline 320, a load/multiply instruction pipeline 322, a load/store instruction pipeline 326, a skid buffer 334, a convert and classify unit 336 and a load mapper 338. Rename-1 unit 310 is coupled to rename-2 unit 312 and is configured to receive a speculative top of stack (TOS) tag and tag word 352. Rename-2 unit 312 is coupled to future file tag array 328, architectural tag array 330, retire queue 316, skid buffer 334, scheduler 314, and load mapper 338. Convert and classify unit 336 is also coupled to load mapper 338, which in turn is coupled to execution and pipe control unit 340 along with instruction status register file 342 and scheduler 314. Register file 318 receives inputs from convert and classify unit 336, load mapper 338 and scheduler 314, and outputs data to source operand bus 348. Source operand bus 348 is in turn coupled to instruction pipes 320, 322, and 326. Finally, instruction pipes 320, 322, and 326, and floating point status/control/tag words 344 are all coupled to result bus 346. While floating point status/control/tag words 344 and speculative top of stack and tag word 352 are shown separately in the figure for explanatory purposes, these tags may be stored together with future file tags 328 and architectural register tags 330 in a single storage location, e.g., within register file 318, execution and pipe control unit 340, or retire queue 316.

Rename-1 unit 310 receives up to three instructions per clock cycle. As previously noted, these may be any combination of floating point, MMX, or 3DX instructions. Rename-1 nit 310 converts stack-relative register operands into absolute register operands. The x86 instruction set and architecture defines eight floating point registers that are accessed in a stack-like manner (i.e., relative to a top-of-stack pointer). For instructions with memory operands, e.g., FLD instructions (floating point load), no conversion is necessary. Instead, the sources are simply identified as being memory operands rather than register operands. Rename-1 unit 310 also assigns each instruction to one of three instruction pipelines, either load/store pipeline 326, add pipeline 320, or multiply pipeline 322.

Rename-2 unit 312 performs true register renaming. Upon receiving the instructions from rename-1 unit 310, rename-2 unit 312 reads three registers from a “free list” of the available registers stored within retire queue 316. Once the registers have been read, rename-2 unit 312 assigns one to the destination register of each instruction. To rename the source registers, rename-2 unit 312 indexes tag future file 328 using the absolute register number for each source register. Tag future file 328 stores tags that identify which registers store the current speculative future state of each of the sixteen architectural registers in FPU 36. Similarly, architectural register tag file 330 stores tags which identify which registers within register file 318 store the current architectural (non-speculative) state of FPU 36. Note, of the sixteen registers that define FPU 36's state (architectural or speculative), eight are architectural registers (i.e., floating point stack or MMX registers) and eight are micro-architectural registers (i.e., registers that store internal state information that is not generally accessible to the programmer). The old destination registers are then read from the tag future file 328 and written to the tail of the free list. Finally, tag future file 328 is updated by storing tags for the new destination registers.

Memory operands may be handled by assigning them the same register tag as the destination register. This is because load data will be converted and directly written into the destination register when it is received from load/store pipeline 326. In the case of an FLD instruction, no further execution is required, although the FLD instruction is still assigned to an execution pipeline for the purpose of signaling completion to reorder buffer 32.

Once the three instructions have passed through rename-1 unit 310 and rename-2 unit 312, the instructions are represented in a three operand format (i.e., first source operand, second source operand, and destination operand). While the first source operand is always a register operand, a bit in the opcode may be used to indicate whether the second operand is a register operand or a memory operand.

From rename-2 unit 312 the instructions are passed to scheduler 314, where the three instructions are allocated a “line” of storage. If scheduler 314 is full, the instructions may be stored in skid buffer 334 until such time as there is room within scheduler 314. After receiving the three instructions, scheduler 314 snoops result bus 346 and source operand bus 348. Concurrently with allocating the line of storage and snooping, retire queue 316 allocates one entry for each instruction. The entries store the destination register tags, the absolute destination register number, and the old destination register number. Additional information may also be included, e.g., information that may be needed to update the architectural state at retire time.

On the cycle following their entry into scheduler 314, the instructions are available for scheduling. Scheduler 314 examines all of the stored instructions and issues the oldest instructions which meet the following criteria: (1) the instruction pipe to which the instruction has been assigned is available, (2) the result bus for that instruction pipe will be available on the clock cycle in which the instruction will complete (this is dependent upon the latency of the particular instruction), and (3) the instruction's source registers and or memory operands are available. In this embodiment, scheduler 314 may schedule up to three instructions per clock cycle. Each of the three instruction pipes 320, 322, and 326 may accept a new instruction every clock cycle. Note other embodiments capable of scheduling four or more instructions are also possible and contemplated.

Once all three entries in a line are scheduled, that line is free to be compacted out of scheduler 314. When the instructions are conveyed from scheduler 314 to their respective instruction execution pipeline, their source operands are read. In some cases, the source data will come from a register, while in other cases the source data will come from a “bypass”. A bypass refers to the practice of result forwarding. Result forwarding involves conveying the results from a recently executed instruction directly to other instructions that depend upon that result. Using result forwarding allows the result to be used in subsequent instructions without having to wait for the result to be stored in a register and then read from the same register.

Each instruction execution pipe 320, 322, and 326 may be configured as a four-stage pipeline. In the first stage of each pipeline, the result buses are read and the input data is taken from either the source operand bus (if the data is within register file 318) or the result bus (if a bypass is being performed). Once the source data has been received, each instruction pipe may begin performing the appropriate computation.

In the embodiment shown in the figure, instruction pipe 320 is configured to perform load and addition operations, instruction pipe 322 is configured to perform load and multiplication operations, and instruction pipe 326 is configured to perform load and store operations. Both instruction pipes 320 and 322 may be configured to perform certain MMX instructions. Instruction pipe 322, which comprises multiplier 50, may also be configured to perform iterative calculations that involve multiplication, e.g., reciprocal operations, division operations, and square root operations, under the control of control unit 110, division/square root ROM 178, and, if a remainder is called for, remainder control unit 176. Constant ROM 174 is a read only memory configured to store a plurality of constants that may be used to calculate initial values for these iterative calculations. Division/square root ROM 178 is a read only memory which stores sequence information for division and square root functions, as described in greater detail below. Note, in some embodiments control unit 110 may be part of execution and pipe control unit 340.

In some cases, instruction operands or the results generated by executing an instruction may be too small to fit within the operand or result's standard data format. These numbers are referred to as “denormals”. While normalized floating point values have a non-zero exponent and a one in the most significant bit of the significand, i.e., the bit directly to the left of the binary radix point (e.g., 1.001010. . . ), denormals are represented with a zero exponent and a zero in the most significant bit of the significand (e.g., 0.000101. . . ). Denormal load data is detected and tagged by convert and classify unit 336. Denormal results generated by during execution within instruction pipes 320, 322, and 326 are tagged when they are generated. Execution and pipe control unit 340 detects the presence of the denormal tags and calls an appropriate microcode routine from MROM 34 to handle the denormal data.

At the end of the final execution stage, the data is placed on result bus 346. This makes the result data available for an instruction entering the first stage of one of the instruction execution pipelines during the next clock cycle. Once the data is on the result bus, it may also be written into register file 318. Instead of being stored in register file 318, store data is sent to the load/store unit 26. The reorder buffer tag and any exception information is sent back to reorder buffer 32. At this point, the instructions are complete. However, they are still speculative. When the instructions reach the bottom of reorder buffer 32 (assuming there is no branch misprediction or exception abort), reorder buffer 32 notifies FPU 36 that the instructions should be retired. The speculative state of the floating point unit 36 is committed to the architectural state when retire queue 316 updates the tags for the architectural register file 328, and the destination register tags in retire queue 316 are written to the architectural register file 318.

Convert and classify unit 336 receives all load data, classifies it by data type, and converts it to an internal format if necessary. In one embodiment, convert and classify unit 336 appends a three bit classification tag to each data item. The three bit tag classifies the accompanying data as one of the following eight potential data types: (1) zero, (2) infinity, (3) quiet NaN, (4) signaling NaN, (5) denormal, (6) MMX, (7) normal, or (8) unsupported. NaN is a standard abbreviation for “Not-a-Number”. While representations may vary across different implementations, zero data types are typically represented with a zero exponent and a zero significand. Similarly, infinity data types are typically represented with an exponent comprising all asserted ones. A quiet NaN (“QNaN”) is generated whenever a floating point instruction causes an invalid operation, e.g., a square root operation on a negative number. A signaling NaN (“SNaN”), unlike a quiet NaN, generates an exception when used. Signaling NaNs are not generated by FPU 36 and are typically only used by programmers to signal particular error conditions. The table below illustrates the characteristics of each data type for x86 compatible floating point units (wherein “x” represents either a one or a zero):

Sign Exponent Significand Value x 00 . . . 00₂ 0.00 . . . 00₂ Zero x 11 . . . 11₂ 1.00 . . . 00₂ Infinity x 11 . . . 11₂ 1.1xx . . . xx₂ QNaN x 11 . . . 11₂ 1.0xx . . . xx₂ SNaN x 00 . . . 00₂ 0.xx . . . xx₂ Denormal

MMX data types are 64 bits wide and comprise either eight packed 8-bit bytes, four packed 16-bit words, or two packed 32-bit double-words. MMX data types may be detected by the MMX opcodes which precede them. Normal data types are standard floating point values that are either single precision, double precision, or extended precision (before they are translated into an internal data format) and that do not have the characteristics of any of the previously described data types. Unsupported data types are extended precision bit patterns that do not fall into any of the previously described data types and that fall outside of the normal data type as defined by IEEE Standard 754. For example, an extended precision bit sequence having a 0 sign bit, a biased exponent of 11 . . . 11, and a significand in the format (f.ff . . . ff) of 0.11 . . . 11 is an unsupported value. Note, however, in other embodiments larger or smaller classification tags and additional or fewer data types may be implemented.

The data types and exemplary formats illustrated above describe the data as it is received and identified by convert and classify unit 336. Once convert and classify unit 336 classifies the data, the classification tag may be used to identify some or all of the data's properties. For example, if a value is classified as a zero, it may be identified solely by its classification tag instead of having to perform a wide comparison of each bit in the exponent and significand portions of the value. The classification tags may accompany the data throughout FPU 36 and may be stored in register file 18 along with the data.

As discussed above, when data from a load instruction is received by FPU 36, the data is routed to convert and classify unit 336. A corresponding reorder buffer tag accompanies the data and is routed in parallel to load mapper 338. As previously noted in the description of microprocessor 10, the reorder buffer tag identifies the sequence in which out of order instructions should be retired (i.e., committed to architectural state). For load instructions, the reorder buffer tag follows the data from load/store unit 26 to FPU 36. Load mapper 338 receives the reorder buffer tag and translates it into a data register tag. The data register tag indicates which data register within register file 318 the corresponding data is to be loaded into.

Execution and pipe control unit 340 tracks the status of each stage in instruction pipes 320, 322, and 326. Execution and pipe control unit 340 contains timing information enabling it to determine the future availability of each instruction pipe. For example, when an FMUL (floating point multiply) instruction begins execution in multiplication instruction pipe 322, control unit 340 uses its stored timing information to notify scheduler 314 that the result will be available for output on result bus 346 four clock cycles later. This timing information allows scheduler 314 to efficiently schedule instruction for execution in instruction pipes 320, 322, and 326. Control unit 320 also tracks the status of each pipe stage, receiving and prioritizing exceptions from instruction pipes 320, 322, and 326.

FPU status word, control word, and tag word (collectively, words 344) are stored within retire queue 316 and indicate which of the status and control registers within register file 318 contain the FPU's current architectural state. For example, in one embodiment register file 318 may comprise 88 registers, i.e., 16 registers to store the current architectural state of FPU 36 (see below), and 72 speculative registers to store the speculative state of FPU 36. Of the 72 speculative registers, 16 of them store the “current” speculative state. Of each set of 16 registers that store a particular state of FPU 36 (whether the state is architectural or speculative), eight registers are FPU stack registers and eight registers are micro-architectural registers that store state information that is only accessible to microcode instructions within FPU 36, i.e., they are not accessible to the programmer and store only internal state information. In one embodiment, each register in register file 314 is 90 bits long, with 87 bits providing storage for internal format data (e.g., one sign bit, 18 exponent bits, and a 68-bit significand) and 3 class bits.

Instruction status register file 342 stores information for execution and pipe control unit 320. As a result of instructions executing out of order in FPU 36, exceptions that occur within instruction pipes may need to be stored until the instructions generating them are the next to be retired. Retire queue 316 reads instruction status register file 342 when it retires instructions and updates the architectural floating point status word (FPSW) and floating point control word (FPCW) and tag word (collectively, 344) accordingly. This information is conveyed to rename-1 unit along with the current speculative top of stack 352 and on result bus 346.

Details of One Embodiment of Multiplier 50

Turning now to FIG. 4, more detail of one embodiment of multiplier 50 is shown. In this embodiment, multiplier 50 comprises a partial product generator 60, a partial product selection logic unit 62, and an adder 64. As shown in the figure, partial product generator 60 is coupled to selection logic unit 62, which is in turn coupled to adder 64. When one of execution units 36C-36E receives an instruction invoking the multiplication function, the execution unit conveys two operands to multiplier 50, i.e., a multiplicand operand 72 and a multiplier operand 74. Partial product generator 60 is coupled to receive multiplicand operand 72, which is used as a starting value for calculating a plurality of partial products 70. For example, if partial product generator 60 is configured to use the 2-bit version of Booth's algorithm, the following partial products would be generated: the multiplicand itself (“+M”), a shifted version of the multiplicand (“+2M”), an inverted version of the multiplicand (“−M”), a shifted and inverted version of the multiplicand (“−2M”), and two constants, i.e., a positive zero (“+0”) and a negative zero (“−0”) in two's complement form.

Partial product selection unit 62 is coupled to receive multiplier operand 74. Selection unit 62 is configured to select a number of partial products from generator 60 based upon particular fields within multiplier operand 74. For example, using the 2-bit version of Booth's algorithm, multiplier operand 74 is padded with leading and trailing zeros (assuming an unsigned multiplication is being performed), and then one partial product is selected by each 3-bit field within the operand.

Finally, adder 64 is configured to receive and sum the partial products selected by selection unit 62. As noted in the figure, the selected partial products 68 are shifted before they are summed. The resulting final product 76 is output to the execution unit that transmitted the operands.

While multiplier 50 may be configured to perform multiplication using a number of different algorithms, the embodiment shown in the figure is configured to use a modified version of Booth's Algorithm to improve multiplication times. Booth's algorithm relies upon calculating a number of partial products and then summing them to obtain a final product. Booth's algorithm is able to improve multiplication times over the standard “add-and-shift” algorithm by reducing the number of partial products that need to be summed in order to obtain the final product. For example, in performing an 8-bit by 8-bit multiplication, the shift-and-add algorithm generates eight partial products. By contrast, same 8-bit by 8-bit multiplication using the 2-bit version of Booth's algorithm generates only five partial products. This reduction in the number of partial products is illustrated in FIGS. 5A and 5B.

Note that multiplier 50 may be configured to use other algorithms, e.g., a shift-and-add algorithm or a 3-bit version of Booth's algorithm. Furthermore, multiplier 50 may be configured to accept and calculate differing bit-widths of operands, e.g., 32, 64, 80, and 87 bits. Higher bit widths such as 87-bits and 90-bits may be used internally in the multiplier for greater precision.

Algorithms for Iterative Calculations

In order to further conserve die space, multiplier 50 may be configured to perform other calculations in addition to multiplication. For example, multiplier 50 may be configured to perform division and square root operations. To allow multiplier 50 to perform division, division operations may be written as the product of the dividend and the reciprocal of the divisor, or

Q=α/b=α×(1/b),  (1)

where Q is the quotient, α is the dividend, and b is the divisor. In this case, the challenge becomes how to efficiently compute the reciprocal of the divisor. The following sections derive two possible iterative algorithms that may be used to determine the reciprocal. Note these derivations are presented for explanatory purposes and are not meant to be limiting. Other iterations are possible and contemplated.

Newton-Raphson Algorithm

In the Newton-Raphson algorithm, a “priming” function is chosen which has a root at the reciprocal. In general, there are many root targets that could be used, including {fraction (1/b)}, 1/b², {fraction (α/b)}, and 1−{fraction (1/b)}. The choice of which root target to use is arbitrary. The selection is made based on convenience of the iterative form, its convergence rate, its lack of divisions, and the overhead involved when using a target root other than the true quotient.

The most widely used target root is the divisor reciprocal {fraction (1/b)}, which is the root of the following priming function:

f(X)=1/X−b=0.  (2)

The quadratically converging Newton-Raphson algorithm is given by: $\begin{matrix} {{x_{i} + 1} = {x_{i} - {\frac{f({xi})}{{f1}({xi})}.}}} & (3) \end{matrix}$

The Newton-Raphson algorithm of equation (3) is then applied to equation (2), and this iteration is then used to find an approximation to the reciprocal as follows: $\begin{matrix} {X_{i} = {{X_{i} - \frac{f({xi})}{{f1}({xi})}} = {{X_{i} + \frac{\left( {{1/X_{i}} - b} \right)}{\left( {1/X_{i}} \right)}} = {X_{i} \times {\left( {2 - {b \times X_{I}}} \right).}}}}} & (4) \end{matrix}$

The corresponding error term is given by the following equation:

ε_(i)+1=ε_(i) ²(b).

Thus the error in the reciprocal decreases quadratically after each iteration. As can be seen from the general relationship expressed in equation (4), each iteration involves two multiplications and a subtraction. The subtraction is equivalent to forming the two's complement and can be replaced by it. Thus, two dependent multiplications and one two's complement operation are performed for each iteration. The final quotient or result is obtained by multiplying the computed reciprocal with the dividend.

Rather than performing a complete two's complement operation at the end of each iteration to form (2−b×X_(i)), it is possible instead to simply implement the one's complement of b×X_(i). This only adds a small amount of error, as the one's and two's complement operations differ only by one unit in the last place (ulp). The one's complement avoids the latency penalty of carry-propagation across the entire result of the iteration, replacing it by a simple inverter delay.

Series Expansion

A different method of deriving an iteration is based on a series expansion. A name sometimes given to this method is Goldschmidt's algorithm. Consider the following Taylor series expansion of a function g(y) at a point p: $\begin{matrix} {{g(y)} = {{g(p)} + {\left( {y - p} \right)\quad {g^{\prime}(p)}} + {\frac{\left( {y - p} \right)2}{2!}\quad {g^{''}(p)}} + \cdots + {\frac{\left( {y - p} \right)n}{n!}\quad {g^{(n)}(p)}} + {\cdots.}}} & (5) \end{matrix}$

In the case of division, it is desirable to find the expansion of the reciprocal of the divisor, such that

g={fraction (a/b)}=a×g(y),  (6)

where g(y) can be computed by an efficient iterative method. A straightforward approach might be to set g(y) equal to 1/y with p=1, and then to evaluate the series. However, it is computationally easier to let g(y)=1/(1+y) with p=0, which is the Maclaurin series. In this case, the function is formed as follows:

g(y)=1/1+y=1−y+y ² −y ³ +y ⁴− . . . .  (7)

To ensure that g(y) is equal to 1/b, the substitution y=b−1 is made, wherein b is bit normalized such that 0.5≦b<1, and thus y≦0.5. Then, the quotient can be written as $q = {{a \times \frac{1}{1 + \left( {b - 1} \right)}} = {{a \times \frac{1}{1 + y}} = {a \times {\left( {1 - y + y^{2} - y^{3} + \cdots} \right).}}}}$

This equation can be written in factored form as follows:

q=a×[(1−y)(1+y ²)(1+y ⁴)(1+y ⁸) . . . ].  (8)

This expansion can be implemented iteratively as follows. An approximate quotient can be written as ${q_{i} = \frac{N_{i}}{D_{i}}},$

where N_(i) and D_(i) are iterative refinements of the numerator and denominator after step i of the algorithm. By forcing D_(i) to converge toward 1, N_(i) converges toward q. Effectively, each iteration of the algorithm provides a correction term (1+y^(2i)) to the quotient, thereby generating the expansion of equation (8).

Initially, N₀ is set to equal α and D₀ is set to equal b. To reduce the number of iterations, α and b are both prescaled by a more accurate approximation of the reciprocal. Next, the algorithm is run on the scaled α′ and b′. For the first iteration, N₁ equals R₀×N₀ and D₁ equals R₀×D₀, where R₀=1−y=2−b, or simply the two's complement of the divisor. Then,

D₁=D₀×R₀ =b×(1−y)=(1+y)(1−y)=1−y ².

Similarly,

N₁N₀×R₀=Δ×(1−y).

For the next iteration, R₁ is set to equal 2−D₁, the two's complement of the new denominator, which results in the following equations:

R₁=2−D₁=2−(1−y ²)=1+y ²

N₂=N₁×R₁=α×[(1−y)(1+y ²)]

D₂=D₁×R₁=(1−y ²)(1+y ²)=(1−y ⁴).

Continuing, a general relationship can be developed, such that each step of the iteration involves the following two multiplications:

N_(i+1)=N_(i)×R_(i) and D_(i+1)=D_(i)×R₁,  (9)

and the following two's complement operation:

R_(i+1)=2−D_(i+1).  (10)

As previously discussed, the two's complement operation can be replaced with the simpler one's complement operation, thereby reducing the total delay and adding only a small error to the result.

After i steps,

N_(i)=α×[(1−y)(1+y ²)(1=y ⁴) . . . (1+y ^(2i))]  (11)

and

D_(i)=(1−y ^(2i)).  (12)

Accordingly, N converges quadratically toward q, and D converges toward one. This can be seen in the similarity between the formation of N_(i) in equation (11) and the series expansion of q in equation (8). So long as b is normalized in the range 0.5≦b<1, then y<1, and each correction factor (1+y^(2i)) doubles the precision of the quotient. This process continues iteratively as shown until the desired accuracy of q is obtained.

For division, a comparison of equation (11) using the substitution y=b−1 with equation (4) using X₀=1 shows that the results are identical for every iteration. Thus, the series expansion is mathematically equivalent to the Newton-Raphson iteration for X₀=1. Additionally, each algorithm can benefit from a more accurate starting approximation of the reciprocal of the divisor to reduce the number of iterations before reaching the desired accuracy. Note, however, that the implementations of these algorithms are different.

First, the Newton-Raphson algorithm converges to a reciprocal, which is then multiplied by the dividend to compute the quotient. In contrast, the series expansion first prescales the numerator and the denominator by the starting approximation and then converges directly to the quotient. Each iteration in both algorithms comprises two multiplications and a two's complement operation. From equation (4) it is evident that the multiplications in Newton-Raphson are dependent operations. As a result of the sequential nature of the operations, the latency of this algorithm is higher than that of the series expansion algorithm. This latency is illustrated in greater detail below. In the series expansion implementation, the two multiplications of the numerator and denominator are independent operations and may occur in parallel. As a result, the series expansion implementation may be better able to take advantage of a pipelined multiplier to obtain higher performance in the form of lower latency per operation.

However, a second important difference is that the Newton-Raphson iteration is self-correcting. Any error in computing X_(i) can be corrected in subsequent iterations. In contrast, the series-expansion implementation computes the result as the product of independent terms. Therefore, the errors present in each term are not corrected. To account for this error, the multiplications may require extra bits of precision.

Square Root

The square root of an operand may also be computed using the Newton-Raphson equation in a manner similar to division. The choice of priming function to solve must be selected carefully. An initial choice might be the following:

f(X)=X² −b=0,  (13)

which has a root at X={square root over (b)}. However, direct application of the Newton-Raphson equation to (13) will result in the following: $\begin{matrix} {{X_{1} = {X_{0} - \frac{f\left( X_{0} \right)}{f^{\prime}\left( X_{0} \right)}}}{X_{1} = {X_{0} - \frac{\left( {X_{0} - b} \right)}{\left( {2X} \right)}}}{X_{i + 1} = {\frac{1}{2}\quad \left( {X_{i} + \frac{b}{X_{i}}} \right)}}} & (14) \end{matrix}$

Unfortunately, this direct application leads to an iteration which contains a division, which itself is an operation that requires an iteration in order to be computed. Another method for computing a square root is to rewrite the compUtation as the following product: $\sqrt{b} = {b \times {\frac{1}{\sqrt{b}}.}}$

This leads to a priming function of

f(X)={fraction (1/X)}−b=0.  (15)

When the Newton-Raphson equation is applied, the iteration becomes as follows: $\begin{matrix} {{X_{1} = {X_{0} - \frac{f\left( X_{0} \right)}{f^{\prime}\left( X_{0} \right)}}}{X_{1} = {X_{0} - \frac{{1/X_{0}} - b}{{- 2}/X_{0}}}}{X_{i + 1} = {\frac{1}{2} \times X_{i} \times \left( {3 - {b \times X_{i}}} \right)}}} & (16) \end{matrix}$

Thus, each iteration I of the total n iterations required the following three steps:

Q_(i,1)=X×G_(i−1),

Q_(i,2)=3−Q_(i,1)×G_(i−1),

and

G_(i)=½×(Q_(i,2)×G_(i−1)),  (17)

wherein G₀ is the initial approximation to the reciprocal square root. Thus, the Newton-Raphson iteration for the reciprocal square root requires three multiplications, a subtraction, and a division by two (which can be implemented as a shift). The final square root is obtained by multiplying the inverse square root result with the input operand. However, the same results can be accomplished without an additional multiplication step by changing the third step in the final iteration to ½×(Q_(n,2)×Q_(n,1)).

The development for square-root calculations using a series expansion implementation proceeds similarly. Initially, let N₀=α×X₀ ² and D₀=α×X₀, where X₀ is the initial approximation to the reciprocal square root of a. A general relationship is developed, such that each step of the iteration involves three multiplications:

N_(i+1)=N_(i)×R_(i) ²,

D_(i+1)=D_(i)×R_(i),

a subtraction, and a shift: $\begin{matrix} {R_{i} = {\frac{3 - N_{i}}{2}.}} & (18) \end{matrix}$

From this iteration, N converges quadratically toward 1, and D converges toward {square root over (α)}.

Concurrent Execution

As described in the previous section, iterative calculations for performing operations such as division and square root involve several sequential multiplication operations which converge toward the desired result. These multiplication operations, along with other operations in the iteration, may monopolize the multiplier for a substantial number of clock cycles. As previously noted, this may be particularly true of implementations that use the Newton-Raphson iteration.

Monopolization of the multiplier is undesirable because other independent multiplication operations may be blocked from execution while the iterative calculation is being performed. For example, if three iterations are performed and each iteration requires two multiplications, then the multiplier is “blocked” for a total of six clock cycles (assuming each multiply operation requires one clock cycle).

A factor which may aggravate this situation is pipelining within the multiplier. In order to achieve a higher clock frequency and greater throughput, multipliers may be pipelined. Using multiplier 50 of FIG. 4 as an example, partial product generation and selection may be performed in the first pipeline stage, partial product addition may occur in the second and third pipeline stages, and rounding may be performed in the fourth pipeline stage. While pipelining may increase a multiplier's average throughput, it may also have the undesirable effect of increasing the blocking penalty for iterative calculations. Using the previous example, a four-stage pipelined multiplier performing three iterations that each require two multiplications, may block independent multiplication instructions for ten or more clock cycles (assuming each pipeline stage requires one clock cycle).

Turning now to FIG. 6, a chart illustrating this blocking phenomena is shown. The chart depicts the timing relationship between pipeline stages for a multiplier having a four stage pipeline during execution of an extended precision division instruction. Execution of the instruction requires a total of twenty-four clock cycles. The first three clock cycles (not shown) are required to read in operands A and B and determine initial estimate X₀. As the figure illustrates, first iteration 90 requires four clock cycles to complete. First iteration 90 comprises a first multiplication operation, D₀=X₀×B, an inversion operation, R₀=(D₀)⁻¹, and a second multiplication operation, N₀=A×X₀. Second iteration 92 also comprises a first multiplication operation, D₁=D₀×R₀, an inversion operation, R₁=(D₁)⁻¹, and a second multiplication operation, N₁=N₀×X₀. The blocking phenomena is aggravated because the second iteration 92 may not begin executing until the results from the first iteration 90, namely D₀ and R₀, are known. As a result, one or more pipeline stages within the multiplier may sit idle, effectively stalling because of the inherent delays in the iterative calculation. Each multiplier pipeline stage sits idle between performing the first and second iterations. This is illustrated by shaded blocks 86 a-d.

In one embodiment, multiplier 50 may be configured to remedy this problem by concurrently executing complex iterative calculations and simple independent multiplication operations. As used herein, “simple” and “independent” refer to multiplication operations that are not part of an iterative calculation and that are ready to be executed, i.e., without unresolved operand dependencies.

Turning now to FIG. 7, one embodiment of multiplier 50 configured to concurrently perform complex iterative calculations and independent multiplication operations is shown. In this embodiment, multiplier 50 comprises multiplier control unit 110, a multiplier core 112, a read-only memory (“ROM”) 174, a plurality of storage registers 114, and two multiplexers, 776 and 780. Multiplier core 112 may comprise a number of different components. For example, multiplier core 112 may comprise components from multiplier 50 as illustrated in FIG. 4, e.g., partial product generator 60, partial product selection logic 62, and partial product array adder 64. Other known configurations for multiplier core 112 may also be used, e.g. a standard multiplier using an add and shift algorithm. In this embodiment, multiplier core 112 is pipelined and comprises four pipelined stages. Once again, however, other numbers of pipeline stages are possible, e.g. six pipeline stages.

In addition to multiplier core 112, multiplier 50 also comprises two operand inputs, multiplicand input 72 and multiplier input 74. Each of these inputs is coupled to a respective multiplexer 776 or 780. Storage registers 114 and ROM 174 are also coupled to multiplexers 776 and 780. Multiplexers 776 and 780 are controlled by multiplier control unit 110 and are configured to select which inputs will be multiplied by multiplier core 112. Multiplier control unit 110 directs multiplexers 776 and 780 to select appropriate values for input to multiplier core 112 based upon opcode 116 and an internal clock cycle counter 120. As in previous embodiments, ROM 174 is configured to receive an operand as input and output a corresponding initial estimate X₀ of the result. ROM 174 may also receive all or a portion of opcode 116 to indicate which table to access if multiple iterative functions are supported in multiplier 50. Note that in some embodiments, the value output by ROM 174 may require further calculation before it is used. In still other embodiments, part or all of ROM 174 may be replaced with combinatorial and arithmetic logic configured to calculate an initial estimate.

Multiplier core 112 receives the selected input values from multiplexer 776 and 780. Multiplexer core 112 multiplies these input values as directed by multiplier control unit 110. For example, if opcode 116 indicates that a simple multiplication operation is to be performed, then multiplier control unit 110 directs multiplier core 112 to multiply the inputs provided by multiplexers 776 and 780 and output the results. If, however, opcode 116 indicates that an iterative calculation is to be performed, then multiplier core 112 performs the first step of the iteration. For example, multiplier core 110 may multiply the selected inputs from multiplexers 776 and 780, and then store both an inverted and non-inverted version of the intermediate results in storage registers 114. During the next iteration, multiplier control unit 110 may cause multiplexers 776 and 780 to select the corresponding results from storage registers 114 for multiplication.

In order to allow complex iterative calculations and simple independent multiplication operations to execute concurrently, multiplier control unit 112 may be configured to initialize internal counter 120 upon receiving an opcode 116 that corresponds to an iterative calculation. Upon receiving such an opcode, multiplier control unit 110 may access an internal ROM or internal logic structure that stores the sequence of operations that comprise the particular opcode. Because the instruction and timing sequence for each type of iterative calculation is constant, control unit 110 is able to assert control signal NEWMULINFOUR 118 four clock cycles before the first pipeline stage in multiplier core 110 experiences an idle cycle. The four cycle advanced notice provided by NEWMULINFOUR 118 allows control logic outside multiplier 50 to select independent multiplication instructions that are ready to be executed. These instructions are then dispatched to multiplier 50 during the appropriate clock cycle. When multiplier 50 receives the opcode 116 corresponding to an independent multiplication instruction, it directs multiplexers 776 and 780 to select the corresponding operands and multiplier core 112 to execute the instruction during the idle cycles within the iterative calculation. A detailed example of the operation of multiplier control unit 110 is explained below.

Turning to FIG. 8, a chart illustrating the operation of an embodiment of multiplier 50 configured to allow concurrent execution of complex iterative calculations and simple independent multiplication operations is shown. Assuming opcode 116 reveals an iterative division calculation is to be performed, multiplier control unit 110 resets internal counter 120 to indicate the first clock cycle. During this first clock cycle, ROM 174 begins to access the initial estimate corresponding to operand B and the particular opcode 116. As previously noted, the first multiplication operation of the iterative calculation begins on the fourth clock cycle, reflecting the read access time of ROM 174 and any time that may be required to calculate X₀ from the output of ROM 174 if ROM 174 does not explicitly store X₀ in a useable form. Multiplier control unit 110 does not assert NEWMULINFOUR 118 during this first clock cycle because the first stage of the pipeline in multiplier core 112 will not be available to begin executing an independent simple multiplication instruction during the fifth clock cycle, i.e., it will be busy performing the second multiplication of the first iteration, N₀=A×X₀. In some embodiments, multiplier core 112 may be configured to execute independent instructions (and complete previous operations) while waiting for X₀ to be generated. These previous and or independent instructions are represented in the figure by instruction blocks 142A-F. Multiplier 50 may also be configured to store operands A and B for later use, e.g., during clock cycles 4-5 and 21. Operands A and B may be store within storage registers 114 or in separate dedicated registers for inputs 72 and 74.

During the second clock cycle, however, multiplier control unit 110 does assert NEWMULINFOUR 118. This is because the first stage of the pipeline in multiplier core 112 will be available to begin executing an independent simple multiplication instruction during the sixth clock cycle. In response to the asserted signal NEWMULINFOUR 118, control logic external to multiplier 50 may efficiently analyze pending operations and schedule the next independent multiplication instruction that is available for execution. Note that in some embodiments this external control may speculatively issue instructions out of program order, while in other embodiments program order may be followed more strictly.

During the third clock cycle, X₀ is output by ROM 174, and multiplier control unit 110 causes multiplexer 776 to select X₀ from ROM 174 and multiplexer 780 to select operand A from multiplier input 74. Once again, multiplier control unit 110 asserts NEWMULINFOUR 118. This is because the first stage of the pipeline in multiplier core 112 will be available to begin executing an independent simple multiplication instruction during the seventh clock cycle.

During the fourth clock cycle, the first pipeline stage of multiplier core 112 begins performing the first multiplication of the first iteration, D₀=X₀×B. This multiplication takes four clock cycles to complete. Multiplier control unit 110 does not assert NEWMULINFOUR 118 during this fourth clock cycle because the first stage of the pipeline in multiplier core 112 will not be available to begin executing an independent simple multiplication instruction during the eighth clock cycle, i.e., it will be busy performing the first multiplication of the second iteration, D₁=D₀×R₀.

During the fifth clock cycle, multiplier control unit 110 causes multiplexer 776 to select operand A from multiplicand input 72 and multiplexer 780 to select X₀. Under the direction of multiplier control unit 110, the first stage of multiplier core 112 begins performing the second multiplication in the first iteration of the division calculation, i.e., N₀=A×X₀. Once again, this multiplication takes four clock cycles to complete. Thus, multiplier core 112 will complete the first iteration after clock cycle eight. Meanwhile, also during the fifth clock cycle, the first multiplication of the iteration, D₀=X₀×B, has propagated to the second stage of the pipeline. Note that one clock cycle of overlap between iterations is possible because the first multiplication of an iteration does not rely upon the results of the second multiplication from the previous iteration. For example, the first multiplication of the second iteration, D₁=D₀×R₀, does not depend upon N₀.

During the sixth clock cycle, external logic conveys to multiplier 50 the opcode and operands for the first independent simple multiplication operation to be performed concurrently with the complex iterative calculation currently underway. Accordingly, multiplier control unit 110 may be configured to direct the first pipeline stage within multiplier core 112 to begin execution of this independent instruction.

Advantageously, in this embodiment ten independent simple multiplications (represented by shaded instruction blocks 148A-D) may be performed concurrently with the iterative operation. As a result, the benefits of pipelining may be had without incurring the undesirable blocking effects. Concurrently with the execution of the final calculation of the iterative division, REM=Q×B−A, additional multiplication instructions may be performed. These instructions are represented in the figure by instruction blocks 144A-C (see clock cycles 22-24).

Turning now to FIG. 9, a diagram illustrating which inputs are selected by one embodiment of multiplexers 776 (SrcA) and 780 (SrcB) during particular clock cycles during the iteration are shown. Note that these selections are exemplary and represent an extended precision multiplication. Other configurations and other iterations are possible. Additional embodiments of multiplier 50 are also contemplated. For example, in one embodiment, multiplexers 776 and 780 may be configured to select multiplicand input 72 and multiplier input 74 by default. Multiplexers 776 and 780 may be configured to select other values, i.e., from storage registers 114 or ROM 174, only upon receiving an indication from multiplier control unit 110.

In yet another embodiment, multiplier 50 may be configured to perform two or more unrelated iterative calculations concurrently. For example, if storage registers were large enough to store the required information (two copies of some information), two different iterative operations could be performed concurrently by multiplier 50. This may require more complex logic and timing within multiplier control unit 110. Note that control unit 110 may comprise a separate state machine and sequencer for each iterative calculation being concurrently performed.

Exemplary Computer System Using Multiplier

Turning now to FIG. 10, a block diagram of one embodiment of a computer system 400 including microprocessor 10 is shown. Microprocessor 10 is coupled to a variety of system components through a bus bridge 402. Other embodiments are possible and contemplated. In the depicted system, a main memory 404 is coupled to bus bridge 402 through a memory bus 406, and a graphics controller 408 is coupled to bus bridge 402 through an AGP bus 410. Finally, a plurality of PCI devices 412A-412B are coupled to bus bridge 402 through a PCI bus 414. A secondary bus bridge 416 may further be provided to accommodate an electrical interface to one or more EISA or ISA devices 418 through an EISA/ISA bus 420. Microprocessor 10 is coupled to bus bridge 402 through a CPU bus 424.

Bus bridge 402 provides an interface between microprocessor 10, main memory 404, graphics controller 408, and devices attached to PCI bus 414. When an operation is received from one of the devices connected to bus bridge 402, bus bridge 402 identifies the target of the operation (e.g. a particular device or, in the case of PCI bus 414, that the target is on PCI bus 414). Bus bridge 402 routes the operation to the targeted device. Bus bridge 402 generally translates an operation from the protocol used by the source device or bus to the protocol used by the target device or bus.

In addition to providing an interface to an ISA/EISA bus for PCI bus 414, secondary bus bridge 416 may further incorporate additional functionality, as desired. For example, in one embodiment, secondary bus bridge 416 includes a master PCI arbiter (not shown) for arbitrating ownership of PCI bus 414. An input/output controller (not shown), either external from or integrated with secondary bus bridge 416, may also be included within computer system 400 to provide operational support for a keyboard and mouse 422 and for various serial and parallel ports, as desired. An external cache unit (not shown) may further be coupled to CPU bus 424 between microprocessor 10 and bus bridge 402 in other embodiments. Alternatively, the external cache may be coupled to bus bridge 402 and cache control logic for the external cache may be integrated into bus bridge 402.

Main memory 404 is a memory in which application programs are stored and from which microprocessor 10 primarily executes. A suitable main memory 404 comprises DRAM (Dynamic Random Access Memory), and preferably a plurality of banks of SDRAM (Synchronous DRAM).

PCI devices 412A-412B are illustrative of a variety of peripheral devices such as, for example, network interface cards, video accelerators, audio cards, hard or floppy disk drives or drive controllers, SCSI (Small Computer Systems Interface) adapters and telephony cards. Similarly, ISA device 418 is illustrative of various types of peripheral devices, such as a modem, a sound card, and a variety of data acquisition cards such as GPIB or field bus interface cards.

Graphics controller 408 is provided to control the rendering of text and images on a display 426. Graphics controller 408 may embody a typical graphics accelerator generally known in the art to render three-dimensional data structures which can be effectively shifted into and from main memory 404. Graphics controller 408 may therefore be a master of AGP bus 410 in that it can request and receive access to a target interface within bus bridge 402 to thereby obtain access to main memory 404. A dedicated graphics bus accommodates rapid retrieval of data from main memory 404. For certain operations, graphics controller 408 may further be configured to generate PCI protocol transactions on AGP bus 410. The AGP interface of bus bridge 402 may thus include functionality to support both AGP protocol transactions as well as PCI protocol target and initiator transactions. Display 426 is any electronic display upon which an image or text can be presented. A suitable display 426 includes a cathode ray tube (“CRT”), a liquid crystal display (“LCD”), etc.

It is noted that, while the AGP, PCI, and ISA or EISA buses have been used as examples in the above description, any bus architectures may be substituted as desired. It is further noted that computer system 400 may be a multiprocessing computer system including additional microprocessors (e.g. microprocessor 10 a shown as an optional component of computer system 400). Microprocessor 10 a may be similar to microprocessor 10. More particularly, microprocessor 10 a may be an identical copy of microprocessor 10. Microprocessor 10 a may share CPU bus 424 with microprocessor 10 or may be connected to bus bridge 402 via an independent bus.

It is still further noted that the present discussion may refer to the assertion of various signals. As used herein, a signal is “asserted” if it conveys a value indicative of a particular condition. Conversely, a signal is “deasserted” if it conveys a value indicative of a lack of a particular condition. A signal may be defined to be asserted when it conveys a logical zero value or, conversely, when it conveys a logical one value. Additionally, various values have been described as being discarded in the above discussion. A value may be discarded in a number of manners, but generally involves modifying the value such that it is ignored by logic circuitry which receives the value. For example, if the value comprises a bit, the logic state of the value may be inverted to discard the value. If the value is an n-bit value, one of the n-bit encodings may indicate that the value is invalid. Setting the value to the invalid encoding causes the value to be discarded. Additionally, an n-bit value may include a valid bit indicative, when set, that the n-bit value is valid. Resetting the valid bit may comprise discarding the value. Other methods of discarding a value may be used as well.

Although the embodiments above have been described in considerable detail, other versions are possible. Numerous variations and modifications will become apparent to those skilled in the art once the above disclosure is fully appreciated. It is intended that the following claims be interpreted to embrace all such variations and modifications. 

What is claimed is:
 1. An apparatus for concurrent execution of multiplication and iterative instructions comprising: a pipelined multiplier, wherein said multiplier is configured to perform simple multiplication operations and complex iterative operations, wherein said multiplier is configured to generate a control signal while performing said complex iterative operations, wherein said control signal is indicative of said multiplier's availability to begin performing simple multiplication operations at a particular time in the future, wherein said particular time is before the completion of said complex iterative operation.
 2. The apparatus as recited in claim 1, wherein said multiplier's availability for a particular clock cycle is a function of the type of iterative operation being performed and the number of clock cycles between said particular clock cycle and the first clock cycle during which said multiplier began executing said complex iterative operation.
 3. The apparatus as recited in claim 2, wherein said pipelined multiplier performs said complex iterative operations using Booth's Algorithm, wherein said pipelined multiplier comprises selection logic to select a set of partial products based on operands for the complex iterative operations, and wherein said pipelined multiplier comprises an adder tree configures to receive and sum the selected set of partial products.
 4. The apparatus as recited in claim 2, wherein said multiplier is configured to begin and complete execution of simple multiplication operations during the execution of said complex iterative operations, wherein said simple multiplication operations are independent from said complex iterative operation.
 5. The apparatus as recited in claim 2, further comprising: a control unit coupled to said multiplier, wherein said control unit is configured to select, based upon said control signal, at least one input for said multiplier from a plurality of potential inputs.
 6. The apparatus as recited in claim 2, further comprising: a first multiplexer coupled to said multiplier, wherein said first multiplexer is configured to select one of a plurality of multiplier values; and a second multiplexer coupled to said multiplier, wherein said second multiplexer is configured to select one of a plurality of multiplicand values.
 7. The apparatus as recited in claim 2, wherein said multiplier is configured to perform one or more simple multiplication operations during said complex iterative operations, wherein said one or more simple multiplication operations are independent from said complex iterative operations.
 8. The apparatus as recited in claim 6, further comprising a plurality of storage registers coupled to said multiplier and said first and second multiplexers, wherein said storage registers are configured to store intermediate results from said complex iterative operations.
 9. The apparatus as recited in claim 2, wherein said complex iterative operations comprise reciprocal, division, square-root, and reciprocal square root operations.
 10. The apparatus as recited in claim 2, wherein said multiplier requires more clock cycles to complete said complex iterative operations than said simple multiplication operations.
 11. The apparatus as recited in claim 2, wherein said complex iterative operations each comprise a plurality of multiplication operations which are independent from said simple multiplication operations.
 12. A microprocessor configured to perform multiplication and iterative operations concurrently, comprising: a multiplier comprising a plurality of pipeline stages, wherein said multiplier is configured to perform an iterative calculation in a predetermined number of clock cycles, wherein at least one of said pipeline stages is idle for at least one clock cycle during said predetermined number of clock cycles, and a control unit configured to dispatch a simple multiplication instruction to said multiplier for execution by said multiplier during said idle clock cycles, wherein said multiplier is configured to complete execution of said simple multiplication instruction before completing execution of said iterative calculation.
 13. The microprocessor as recited in claim 12, wherein said multiplier said multiplier performs said iterative calculation using Booth's algorithm, wherein said multiplier comprises selection logic to select a set of partial products based on operands for the iterative calculation, and wherein said pipelined multiplier comprises an adder tree configures to receive and sum the selected set of partial products.
 14. The microprocessor as recited in claim 12, wherein each of said pipelines stages is idle for at least one clock cycle during said predetermined number of clock cycles.
 15. The microprocessor as recited in claim 12, wherein said multiplier is configured to complete execution of a plurality of multiplication instructions before completing said iterative calculation, wherein each of said plurality of multiplication instructions were started by said multiplier after said iterative calculation.
 16. A method for executing independent multiplication and iterative instructions concurrently comprising: beginning execution of an iterative instruction in a pipelined multiplier, wherein said iterative instruction requires a first number of clock cycles to complete; asserting a control signal during said first number of clock cycles if said multiplier will be available in a predetermined number of clock cycles to begin execution of an independent multiplication instruction; upon detecting an asserted control signal, dispatching said independent multiplication instruction to said multiplier; beginning execution of said independent multiplication instruction before said iterative instruction has completed executing; completing execution of said independent multiplication instruction before said iterative instruction completes execution; and completing execution of said iterative instruction.
 17. The method as recited in claim 16, wherein at least one pipeline stage in said multiplier is available to operate on said independent multiplication instructions during said first number of clock cycles.
 18. The method as recited in claim 17, wherein said multiplier is configured to complete said multiplication instruction in a second number of clock cycle, wherein said second number of clock cycles equals the number of pipeline stages in said multiplier.
 19. The method as recited in claim 17, further comprising selecting a multiplier value and a multiplicand value for said multiplier from a plurality of values comprising intermediate results from said iterative calculations and operands from said multiplication instruction.
 20. The method as recited in claim 19, further comprising storing intermediate results from said iterative instruction in at least one of a plurality of storage registers.
 21. The method as recited in claim 20, wherein said independent multiplication instruction is not part of said iterative instruction.
 22. A microprocessor configured to perform two independent iterative calculations concurrently comprising: a multiplier having a plurality of pipeline stages, wherein said multiplier is configured to perform a first iterative calculation in a predetermined number of clock cycles, wherein each of said pipeline stages is idle for at least one clock cycle during said predetermined number of clock cycles, wherein said multiplier is configured to generate intermediate results for said first iterative calculation after each iteration, wherein said multiplier is configured to assert a control signal indicative of said multiplier's availability to begin performing a new calculation a predetermined number of clock cycles in the future; a control unit configured to dispatch said first iterative instruction to said multiplier based on said control signal, wherein said control unit is further configured to dispatch a second iterative instruction to said multiplier for execution by said multiplier during said idle clock cycle; and a plurality of storage registers coupled to receive intermediate results from said multiplier for said first iterative calculation and said second iterative calculation, wherein said plurality of storage registers are configured to store said intermediate results from said first iterative calculation and said second iterative calculation concurrently.
 23. A method for executing two or more independent iterative instructions concurrently comprising: beginning execution of a first iterative instruction in a pipelined multiplier, wherein said first iterative instruction requires a first number of clock cycles to complete; asserting a control signal during said first number of clock cycles if said multiplier will be available in a predetermined number of clock cycles to begin execution of a second independent iterative instruction; dispatching said second independent iterative instruction to said multiplier; beginning execution of said second independent iterative instruction before said first iterative instruction has completed executing; completing execution of said first independent iterative instruction; and completing execution of said second iterative instruction.
 24. The method as recited in claim 23, wherein said first independent iterative instruction is completed before said second independent iterative instruction.
 25. The method as recited in claim 23, wherein said first independent iterative instruction is completed before said second independent iterative instruction.
 26. The method as recited in claim 23, further comprising: storing intermediate results from said first iterative calculation; and concurrently storing intermediate results from said second independent iterative calculation. 